TOP = __name__ == '__main__'

from IPython.core.magic import  (Magics, magics_class, cell_magic, line_magic, line_cell_magic)

class B(dict):

    def __getattr__(self, name):

        return self.__getitem__(name)

@magics_class

class MyMagics(Magics):

    def __init__(self, shell=None,  **kwargs):

        super().__init__(shell=shell, **kwargs)

        self._vars = B()

        shell.user_ns['VARS'] = self._vars

​

    @cell_magic

    def var(self, line, cell):

        self._vars[line.strip()] = cell.strip()

    @line_cell_magic

    def top(self, line, cell=None):

        if TOP:

            if cell is None:

                cell = line

            ip = get_ipython()

            res = ip.run_cell(cell)

get_ipython().register_magics(MyMagics)

import sys

%top assert sys.version_info[0:2] == (3, 7)

from subprocess import run

import os

def do(command, env=None, shell=False, log=False, **args):

    result = run(command, universal_newlines=True, shell=shell,

                  env=dict(os.environ, **({} if env is None else env)),

                 capture_output=True, **args)

    if log:

        with open('build/do.log', 'a+') as f:

            print(json.dumps({'cmd':command, 'env':env, 'exitcode':result.returncode}), env, file=f)

    return result

import random

random.seed(0)

import shutil

%%top

if shutil.which('lsb_release'):

    res = do(['lsb_release', '-d']).stdout

elif shutil.which('sw_vers'):

    res = do(['sw_vers']).stdout

else:

    assert False

res

%top do(['jupyter', '--version']).stdout

def pip_install(v):

    return do(['pip', 'install', '-qqq', *v.split(' ')]).returncode

%top pip_install('fuzzingbook==0.8.0')

%top pip_install('astor graphviz scipy')

%top pip_install('jupyter_contrib_nbextensions jupyter_nbextensions_configurator')

%top do(['jupyter','contrib','nbextension','install','--user']).returncode

def nb_enable(v): return do(['jupyter','nbextension','enable',v]).returncode

%top do(['jupyter','nbextensions_configurator','enable','--user']).returncode

%top nb_enable('toc2/main')

%top nb_enable('collapsible_headings/main')

%top nb_enable('execute_time/ExecuteTime')

%top nb_enable('codefolding/main')

%top do(['rm', '-rf','build']).returncode

%%var Mimid

# [(

Testing Mimid

# )]

%top VARS['Mimid']

%%var calc_src

# [(

import string

​

def is_digit(i):

    return i in list(string.digits) # Need list() for taints tracking in prototype

def parse_num(s,i):

    n = ''

    while s[i:] and is_digit(s[i]):

        n += s[i]

        i = i +1

    return i,n

​

def parse_paren(s, i):

    assert s[i] == '('

    i, v = parse_expr(s, i+1)

    if s[i:] == '':

        raise Exception(s, i)

    assert s[i] == ')'

    return i+1, v

​

def parse_expr(s, i = 0):

    expr = []

    is_op = True

    while s[i:]:

        c = s[i]

        if c in list(string.digits): # Need list() for taints tracking in prototype

            if not is_op: raise Exception(s,i)

            i,num = parse_num(s,i)

            expr.append(num)

            is_op = False

        elif c in ['+', '-', '*', '/']:

            if is_op: raise Exception(s,i)

            expr.append(c)

            is_op = True

            i = i + 1

        elif c == '(':

            if not is_op: raise Exception(s,i)

            i, cexpr = parse_paren(s, i)

            expr.append(cexpr)

            is_op = False

        elif c == ')':

            break

        else:

            raise Exception(s,i)

    if is_op:

        raise Exception(s,i)

    return i, expr

​

def main(arg):

    return parse_expr(arg)

# )]

%%var mathexpr_src

# [(

import math

​

_CONSTANTS = {

    'pi' : math.pi,

    'e' : math.e,

    'phi': (1 + 5 ** .5) / 2

}

​

_FUNCTIONS = {

    'abs': abs,

    'acos': math.acos,

    'asin': math.asin,

    'atan': math.atan,

    'atan2': math.atan2,

    'ceil': math.ceil,

    'cos': math.cos,

    'cosh': math.cosh,

    'degrees': math.degrees,

    'exp': math.exp,

    'fabs': math.fabs,

    'floor': math.floor,

    'fmod': math.fmod,

    'frexp': math.frexp,

    'hypot': math.hypot,

    'ldexp': math.ldexp,

    'log': math.log,

    'log10': math.log10,

    'modf': math.modf,

    'pow': math.pow,

    'radians': math.radians,

    'sin': math.sin,

    'sinh': math.sinh,

    'sqrt': math.sqrt,

    'tan': math.tan,

    'tanh': math.tanh

}

​

class Parser:

    def __init__(self, string, vars = None):

        self.string = string

        self.index = 0

        self.vars = {} if vars == None else vars.copy()

        for constant in _CONSTANTS.keys():

            if self.vars.get(constant) != None:

                raise Exception("Cannot redefine the value of " + constant)

​

    def getValue(self):

        value = self.parseExpression()

        self.skipWhitespace()

        if self.hasNext():

            raise Exception(

                "Unexpected character found: '" + self.peek() + "' at index " + str(self.index)

            )

        return value

​

    def peek(self):

        return self.string[self.index:self.index + 1]

​

    def hasNext(self):

        return self.index < len(self.string)

​

    def isNext(self, value):

        return self.string[self.index:self.index+len(value)] == value

​

    def popIfNext(self, value):

        if self.isNext(value):

            self.index += len(value)

            return True

        return False

​

    def popExpected(self, value):

        if not self.popIfNext(value):

            raise Exception("Expected '" + value + "' at index " + str(self.index))

​

​

    def skipWhitespace(self):

        while self.hasNext():

            if self.peek() in list(' \t\n\r'):

                self.index += 1

            else:

                return

​

    def parseExpression(self):

        return self.parseAddition()

    def parseAddition(self):

        values = [self.parseMultiplication()]

        while True:

            self.skipWhitespace()

            char = self.peek()

            if char == '+':

                self.index += 1

                values.append(self.parseMultiplication())

            elif char == '-':

                self.index += 1

                values.append(-1 * self.parseMultiplication())

            else:

                break

        return sum(values)

​

    def parseMultiplication(self):

        values = [self.parseParenthesis()]

        while True:

            self.skipWhitespace()

            char = self.peek()

            if char == '*':

                self.index += 1

                values.append(self.parseParenthesis())

            elif char == '/':

                div_index = self.index

                self.index += 1

                denominator = self.parseParenthesis()

                if denominator == 0:

                    raise Exception(

                        "Division by 0 kills baby whales (occured at index " + str(div_index) + ")"

                    )

                values.append(1.0 / denominator)

            else:

                break

        value = 1.0

        for factor in values:

            value *= factor

        return value

​

    def parseParenthesis(self):

        self.skipWhitespace()

        char = self.peek()

        if char == '(':

            self.index += 1

            value = self.parseExpression()

            self.skipWhitespace()

            if self.peek() != ')':

                raise Exception(

                    "No closing parenthesis found at character " + str(self.index)

                )

            self.index += 1

            return value

        else:

            return self.parseNegative()

​

    def parseArguments(self):

        args = []

        self.skipWhitespace()

        self.popExpected('(')

        while not self.popIfNext(')'):

            self.skipWhitespace()

            if len(args) > 0:

                self.popExpected(',')

                self.skipWhitespace()

            args.append(self.parseExpression())

            self.skipWhitespace()

        return args

​

    def parseNegative(self):

        self.skipWhitespace()

        char = self.peek()

        if char == '-':

            self.index += 1

            return -1 * self.parseParenthesis()

        else:

            return self.parseValue()

​

    def parseValue(self):

        self.skipWhitespace()

        char = self.peek()

        if char in list('0123456789.'):

            return self.parseNumber()

        else:

            return self.parseVariable()

    def parseVariable(self):

        self.skipWhitespace()

        var = []

        while self.hasNext():

            char = self.peek()

            if char.lower() in list('_abcdefghijklmnopqrstuvwxyz0123456789'):

                var.append(char)

                self.index += 1

            else:

                break

        s = ''

        for a in var:

            s += a # CHANGE from ORIGINAL to preserve taints. We need to taints.w__ join() calls.

        var = s

        function = _FUNCTIONS.get(var.lower())

        if function != None:

            args = self.parseArguments()

            return float(function(*args))

        constant = _CONSTANTS.get(var.lower())

        if constant != None:

            return constant

​

        value = self.vars.get(var, None)

        if value != None:

            return float(value)

        raise Exception("Unrecognized variable: '" + var + "'")

​

    def parseNumber(self):

        self.skipWhitespace()

        strValue = ''

        decimal_found = False

        char = ''

​

        while self.hasNext():

            char = self.peek()            

            if char == '.':

                if decimal_found:

                    raise Exception(

                        "Found an extra period in a number at character " + str(self.index) + ". Are you European?"

                    )

                decimal_found = True

                strValue += '.'

            elif char in list('0123456789'):

                strValue += char

            else:

                break

            self.index += 1

​

        if len(strValue) == 0:

            if char == '':

                raise Exception("Unexpected end found")

            else:

                raise Exception(

                    "I was expecting to find a number at character " + str(self.index) + " but instead I found a '" + char + "'. What's up with that?")

​

        return float(strValue)

import string

def main(arg):

    p = Parser(arg, {a:ord(a) for a in string.ascii_lowercase if a != 'e'})

    p.getValue()

# )]

%%var microjson_src

# [(

# microjson - Minimal JSON parser/emitter for use in standalone scripts.

# No warranty. Free to use/modify as you see fit. Trades speed for compactness.

# Send ideas, bugs, simplifications to http://github.com/phensley

# Copyright (c) 2010 Patrick Hensley <spaceboy@indirect.com>

​

# std

import math

import myio as io

import types

​

​

# the '_from_json_number' function returns either float or long.

__pychecker__ = 'no-returnvalues'

​

# character classes

WS = ' ' # ''.join([' ','\t','\r','\n','\b','\f'])

DIGITS = ''.join([str(i) for i in range(0, 10)])

NUMSTART = DIGITS + ''.join(['.','-','+'])

NUMCHARS = NUMSTART + ''.join(['e','E'])

ESC_MAP = {'n':'\n','t':'\t','r':'\r','b':'\b','f':'\f'}

REV_ESC_MAP = dict([(_v,_k) for _k,_v in list(ESC_MAP.items())] + [('"','"')])

​

# error messages

E_BYTES = 'input string must be type str containing ASCII or UTF-8 bytes'

E_MALF = 'malformed JSON data'

E_TRUNC = 'truncated JSON data'

E_BOOL = 'expected boolean'

E_NULL = 'expected null'

E_LITEM = 'expected list item'

E_DKEY = 'expected key'

E_COMMA = 'missing comma between elements'

E_COLON = 'missing colon after key'

E_EMPTY = 'found empty string, not valid JSON data'

E_BADESC = 'bad escape character found'

E_UNSUPP = 'unsupported type "%s" cannot be JSON-encoded'

E_BADFLOAT = 'cannot emit floating point value "%s"'

​

NEG_INF = float('-inf')

POS_INF = float('inf')

​

​

class JSONError(Exception):

    def __init__(self, msg, stm=None, pos=0):

        if stm:

            msg += ' at position %d, "%s"' % (pos, repr(stm.substr(pos, 32)))

        Exception.__init__(self, msg)

​

​

class JSONStream:

​

    # no longer inherit directly from StringIO, since we only want to

    # expose the methods below and not allow direct access to the

    # underlying stream.

​

    def __init__(self, data):

        self._stm = io.StringIO(data)

​

    @property

    def pos(self):

        return self._stm.tell()

​

    @property

    def len(self):

        return len(self._stm.getvalue())

​

    def getvalue(self):

        return self._stm.getvalue()

​

    def skipspaces(self):

        "post-cond: read pointer will be over first non-WS char"

        self._skip(lambda c: not c in WS)

​

    def _skip(self, stopcond):

        while True:

            c = self.peek()

            if stopcond(c) or c == '':

                break

            self.next()

​

    def next(self, size=1):

        return self._stm.read(size)

​

    def next_ord(self):

        return ord(next(self))

​

    def peek(self):

        if self.pos == self.len:

            return self.getvalue()[self.pos:]

        return self.getvalue()[self.pos]

​

    def substr(self, pos, length):

        return self.getvalue()[pos:pos+length]

​

​

def _decode_utf8(c0, stm):

    c0 = ord(c0)

    r = 0xFFFD      # unicode replacement character

    nc = stm.next_ord

​

    # 110yyyyy 10zzzzzz

    if (c0 & 0xE0) == 0xC0:

        r = ((c0 & 0x1F) << 6) + (nc() & 0x3F)

​

    # 1110xxxx 10yyyyyy 10zzzzzz

    elif (c0 & 0xF0) == 0xE0:

        r = ((c0 & 0x0F) << 12) + ((nc() & 0x3F) << 6) + (nc() & 0x3F)

​

    # 11110www 10xxxxxx 10yyyyyy 10zzzzzz

    elif (c0 & 0xF8) == 0xF0:

        r = ((c0 & 0x07) << 18) + ((nc() & 0x3F) << 12) + \

            ((nc() & 0x3F) << 6) + (nc() & 0x3F)

    return chr(r)

​

​

def decode_escape(c, stm):

    # whitespace

    v = ESC_MAP.get(c, None)

    if v is not None:

        return v

​

    # plain character

    elif c != 'u':

        return c

​

    # decode unicode escape \u1234

    sv = 12

    r = 0

    for _ in range(0, 4):

        r |= int(stm.next(), 16) << sv

        sv -= 4

    return chr(r)

​

​

def _from_json_string(stm):

    # skip over '"'

    stm.next()

    r = ''

    while True:

        c = stm.next()

        if c == '':

            raise JSONError(E_TRUNC, stm, stm.pos - 1)